6.4. Tek Yönlü Bağlantılı Liste Uygulaması

Program-6.4.'te tek yönlü bağlantılı liste üzerine buraya kadar verilen algoritmaların ve ilgili fonksiyonların bir program içerisinde toplu kullanımı verilmiştir. Dikkatlice incelenmesi ve yazılıp adım adım çalıştırılması önerilir!

Bu program, gereksinime göre bir düğüm için gerekli veri yapısı değiştirilerek farklı uygulamalar için kullanılabilir.

Programın biri ilk, diğeri son olmak üzere iki tane global değişkeni vardır; diğer tüm değişkenler yereldir. BLISTE bağlantılı liste için programcı tarafından tanımlanmış bir veri yapısı/türüdür. Dikkat edilirse topluluk bildiriminde typedef kullanılmıştır. Bu nedenle BLISTE yeni bir veri türü olarak değerlendirilebilir.

Program-6.4. C ile tek-yönlü bağlantılı liste uygulaması

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>

/* Listedeki düğümlerin veri yapısı tanımlaması */
typedef struct topluluk {
int bilgi;
char mesaj[100];
struct topluluk *arka;
}BLISTE;

/* Listenin ilk ve son düğüm adreslerinin tutan işaretçileri */
BLISTE *ilk=NULL, *son=NULL;

/* Fonksiyon bildirimleri */
BLISTE *ara(int);
BLISTE *sil(int);
BLISTE *okuKlavye();
void yazEkrana(BLISTE *);

/* Ana Program*/
main()
{
     BLISTE *eklenecek, *ki;
     int bilgi, sonuc;
     char secim;

     while(1) {
                   puts("\nEkleme\nListeleme\nArama\nSilme\nÇıkış\nSeçiminiz?");

                   secim=getchar();

                   switch(secim) {
                            case 'E': eklenecek=okuKlavye();
                                 if(eklenecek!=NULL)
                                      ekle(eklenecek);
                                 else
                                      puts("Ekleme için Bellek Dolu\n");
                                 break;

                            case 'L': sonuc=listele();
                                 if(sonuc==-1) puts("Boş Liste !");
                                 break;

                            case 'A': puts("Aranan:"); scanf("%d", &bilgi);
                                  ki=ara(bilgi);
                                  if(ki==NULL)
                                      puts("Aranan Bulunamadı");
                                  else
                                      yazEkrana(ki);
                                  break;

                            case 'S': puts("Silinecek:"); scanf("%d", &bilgi);
                                 ki=sil(bilgi);
                                 if(ki!=NULL)
                                      puts("Silindi...");
                            else
                                puts("Silinmek istenen yok!");
                            break;

                            case 'ç':
                            case 'Ç':
                            case 'c':
                            case 'C': puts ("Hoşçakal!");
                                     exit(0);
                            default: puts("Yanlış Seçim!!!\n");
                  } /* switch'in */
          } /* while döngüsünün */
} /* ana programın */

/* Kayıt ekleme fonksiyonu */
int ekle(BLISTE *ki)
{
     if(ilk!=NULL) {
            son->arka=ki;
            son=ki;
            son->arka=NULL;
     }
     else {         /* ilk kayıt ise burası yürütülür */
               ilk=ki;
               son=ilk;
               ilk->arka=NULL;
           }
  return 0;
}

/* Listedeki tüm kayıtları listeleme */
int listele()
{
    BLISTE *p;

    p=ilk; /* Listenin başlangıç adresi p'ye alınıyor */

    if(p==NULL) return -1; /* boş liste */
          while(p) { /* NULL olana kadar dönülür */
                yazEkrana(p);
                p=p->arka;
          }
    return 0; /* listeleme yapıldı anlamında */
}

/* Liste üzerinde bir kayıt arama */
BLISTE *ara(int aranan)
{
    BLISTE *p;

    p=ilk;

    while(p) {
          if(p->bilgi==aranan) /* aranan mı ? */
          return p; /* evet ise adresini gönder */
          p=p->arka; /* hayır ise bir sonrakine geç */
   }

return NULL; /* bulunamamış ise NULL gönder */
}

/* Listeden bir kayıt silme */
BLISTE *sil(int silinecek)
{
    BLISTE *p, *bironceki;

    p=ilk;
    bironceki=NULL;

    while(p) { /* silinecek olan aranıyor... */
        if(silinecek==p->bilgi)
            break;
        bironceki=p;
        p=p->arka;
    } /* silinecek listede varsa o ve bir önceki bulundu */

    if(p!=NULL) {
            if(bironceki==NULL) { /* silinecek olan birinci düğüm! */
                    if(ilk==son) { /* listede yalnızca 1 düğüm varsa */
                        ilk=NULL;
                        son=NULL;
                    }
                    else
                        ilk=ilk->arka;
            }
    else { /* silinecek olan aradan bir düğüm */
        bironceki->arka=p->arka;
        if(bironceki->arka==NULL)
        son=bironceki; /*silinen son düğüm */
       }

    free(p); /* alan serbest bırakılıyor */
    return p; /* NULL'dan farklı adres gönderiliyor */
    }
    else
        return NULL; /* silinmek istenen listede yok */
    }

/* Bir kayıt bilgisini ekrana yazar */
void yazEkrana(BLISTE *yazilacak)
{
    printf("bilgi:%d, mesaj:%s\n",yazilacak->bilgi, yazilacak->mesaj);
}

/* Bir kayıt bilgisini klavyeden okur; dinamik olarak yerleştirir */
BLISTE *okuKlavye()
{
    BLISTE *okunan;

    okunan=malloc(sizeof(BLISTE)); /* dinamik olarak yer isteniyor */
    if(okunan==NULL) /* boş yer verildi mi? */
    return NULL; /* boş yer yok ise NULL gelir */

    puts("Bilgi Giriniz:");
    scanf("%d",&(okunan->bilgi));
    puts("Mesaj Giriniz:");
    scanf("%s", okunan->mesaj);
    return okunan; /* bilginin yerleştirildiği adres gönderiliyor */
}